home *** CD-ROM | disk | FTP | other *** search
/ NeXT Education Software Sampler 1992 Fall / NeXT Education Software Sampler 1992 Fall.iso / Programming / Source / HippoDraw / HippoDrawSrc1.1 / Hippo.subproj / InspectTuple.m < prev    next >
Encoding:
Text File  |  1992-04-25  |  17.0 KB  |  695 lines
  1. /* InspectTuple    by Paul Kunz    October 1991
  2.  * The supervisor for the tuple inspection panel
  3.  * 
  4.  * Copyright (C)  1991  The Board of Trustees of
  5.  * The Leland Stanford Junior University.  All Rights Reserved.
  6.  */ 
  7.  
  8. #import "InspectTuple.h"
  9.  
  10. const char InspectTuple_h_rcsid[] = INSPECTTUPLE_H_ID;
  11. const char InspectTuple_m_rcsid[] = "$Id: InspectTuple.m,v 1.27 1992/04/19 21:42:20 pfkeb Rel $";
  12.  
  13. #import <appkit/Application.h>
  14. #import <appkit/Box.h>
  15. #import <appkit/Form.h>
  16. #import <appkit/Matrix.h>
  17. #import <appkit/NXBrowser.h>
  18. #import <appkit/NXBrowserCell.h>
  19. #import <appkit/OpenPanel.h>
  20. #import <appkit/Pasteboard.h>
  21. #import <appkit/TextField.h>
  22. #import <appkit/Window.h>
  23. #import <appkit/nextstd.h>
  24. #import <objc/List.h>
  25. #import "DrawDocument.h"
  26. #import "HDraw.h"
  27. #import "HGraphicView.h"
  28. #import "HTuple.h"
  29. #import "NewInspector.h"
  30. #import "Plot.h"
  31. #import "stdio.h"
  32. #import "strings.h"
  33. #import <appkit/defaults.h>
  34. #import <sys/types.h>
  35. #import <sys/stat.h>
  36.  
  37. @implementation InspectTuple
  38. - initInspFor:aDraw
  39. {
  40.     [super initInspFor:aDraw];
  41.     
  42.     [NXApp loadNibSection:"InspectTuple.nib" owner:self
  43.            withNames:NO fromZone:[self zone]];
  44.     [theInspector addView:[contentBox contentView]
  45.                   withName:"Tuple List"
  46.           withSupervisor:self];
  47.     
  48.     openPanel = [OpenPanel new];
  49.   /* the following avoids getting "/private/Net/..." as default */
  50.     [openPanel setDirectory:NXHomeDirectory()];
  51.  
  52.     tupleList = [[ List allocFromZone:[self zone]] init]; 
  53.     
  54.     [[fileForm cellAt: 0 :0 ] setSelectable:YES];
  55.     [[fileForm cellAt: 1 :0 ] setEditable:NO];
  56.     [[fileForm cellAt: 2 :0 ] setEditable:NO];
  57.     [[fileForm cellAt: 3 :0 ] setEditable:NO];
  58.     [ fileForm setBordered:YES];
  59.     
  60.     return self;
  61. }
  62. - hTupleForTuple:(ntuple) nt
  63. {
  64.     id            hTuple;
  65.     int            i, count;
  66.     
  67.     count = [tupleList count];
  68.     for ( i = 0; i < count; i++ ) {
  69.         hTuple = [tupleList objectAt:i];
  70.     if ( nt == [hTuple ntuple] ) {
  71.         return hTuple;
  72.     }
  73.     }
  74.     return nil;
  75. }
  76.  
  77. - (BOOL) isNewTupleFile:(const char *)filename
  78. {
  79.     id            hTuple;
  80.     int            i, count;
  81.     
  82.     count = [tupleList count];
  83.     for ( i = 0; i < count; i++ ) {
  84.         hTuple = [tupleList objectAt:i];
  85.     if ( strcmp( [hTuple filename], filename ) == 0 ) {
  86.         return NO;
  87.     }
  88.     }
  89.     return YES;
  90. }
  91. - hTupleForFile:(const char *)filename index:(int)iValue
  92. {
  93.     const char    *altfile;
  94.     id        hTuple;
  95.     int        i;
  96.     
  97.     i = [tupleList count];
  98.     while ( i-- ) {
  99.         hTuple = [tupleList objectAt:i];
  100.     if ( [hTuple index] == iValue ) {
  101.         if ( strcmp( [hTuple filename], filename ) == 0 ) {
  102.         return hTuple;
  103.         }
  104.         altfile = [hTuple altfilename];
  105.         if ( altfile && (strcmp(altfile, filename) == 0 ) ) {
  106.         return hTuple;
  107.         }
  108.     }
  109.     }
  110.     
  111.     return nil;
  112. }
  113. - (int) runModelForTypes
  114. {
  115.     static const char    *const filetype[2] = {"hippo", NULL};
  116.     
  117.     [openPanel setAccessoryView:accessoryView];
  118.     if ( ![openPanel runModalForTypes:filetype] ) {
  119.         return HD_CANCEL;
  120.     }
  121.     return HD_OK;
  122. }
  123. - openTuple:sender
  124. {
  125.     int            irc;
  126.  
  127.     irc = [self runModelForTypes];
  128.     if ( irc == HD_CANCEL ) {
  129.         return self;
  130.     }
  131.     [self openTupleFile];
  132.     return self;
  133. }
  134. - openTupleAsText:sender
  135. {
  136.     [openPanel setAccessoryView:accessoryView];
  137.     if ( ![openPanel runModal] ) {
  138.         return self;
  139.     }
  140.     [self openTupleFile];
  141.     return self;
  142. }
  143. - openTupleFile
  144. { 
  145.     const char        *filename;
  146.     int                 irc;
  147.     BOOL        refFlag;
  148.  
  149.     filename = [openPanel filename];
  150.     refFlag = [refFlagMatrix selectedRow] ? NO : YES;
  151.     irc = [self openTupleFile:filename by:refFlag];
  152.     if ( irc == HD_REPLACE ) {
  153.         [self bindDisplays];
  154.     }
  155.     [self showPanel];
  156.     return self;
  157. }
  158.  
  159. - openTupleFromFile:(const char *)filename by:(BOOL)refFlag
  160. {
  161.     id        hTuple, newTupleList;
  162.     FILE    *infile;
  163.     ntuple    *ntlist;
  164.     display     *dlist;
  165.     char    *suffix;
  166.     int        i, irc;
  167.     BOOL    binFlag;
  168.     
  169.     suffix = rindex(filename, '.' );
  170.     if ( (infile = fopen(filename, "r") ) == NULL ) {
  171.     irc = NXRunAlertPanel("Reason Alert", "Couldn't open file",
  172.             "OK", NULL, NULL);
  173.     return nil;
  174.     }
  175.     if ( suffix && (strcmp(suffix, ".hippo" ) == 0) ) {
  176.         binFlag = YES;
  177.     if ( h_readStream(infile, &dlist, &ntlist) != 0 ) {
  178.         return nil;
  179.     }
  180.     } else {
  181.         binFlag = NO;
  182.         NX_ZONEMALLOC( [self zone], ntlist, ntuple, 2 );
  183.     if ( !(ntlist[0] = h_fileParse( infile, NULL, 0) ) ) {
  184.         NXZoneFree([self zone], ntlist);
  185.         return nil;
  186.     }
  187.     ntlist[1] = NULL;
  188.     }
  189.     irc = fclose( infile );
  190.     
  191.     newTupleList = [[List allocFromZone:[self zone]] initCount:0];
  192.     for ( i = 0; ntlist[i] != NULL; i++ ) {
  193.     hTuple = [[HTuple allocFromZone:[self zone]]
  194.                       initTuple:ntlist[i] file:filename
  195.               by:refFlag mode:binFlag index:i];
  196.     [tupleList addObject:hTuple];
  197.     [newTupleList addObject:hTuple];
  198.     }
  199.     [tupleBrowser loadColumnZero];
  200.     [ self setTuple:ntlist[0] ];
  201.     return newTupleList;
  202. }
  203. - openTuple:pasteBoard
  204.     userData:(const char *)args
  205.     error:(char **)errorMsg
  206. {
  207.     id        hTuple;
  208.     FILE     *infile;
  209.     ntuple    *ntlist;
  210.     const char *const *ptypes;
  211.     const char *data;
  212.     char     filename[25];
  213.     char    *outbuffer;
  214.     int        i, irc, length;
  215.     BOOL    binFlag;
  216.  
  217.     ptypes = [pasteBoard types];
  218.     for ( i = 0; ptypes[i]; i++ ) {
  219.         if ( !strcmp(ptypes[i], NXAsciiPboardType) ) {
  220.         [pasteBoard readType:ptypes[i] data:&data length:&length];
  221.         NX_ZONEMALLOC([self zone], outbuffer, char, (length+2) );
  222.         strncpy( outbuffer, data, length);
  223.         outbuffer[length] = '\n';
  224.         outbuffer[length+1] = '\0';
  225.         strcpy(filename,"/tmp/file000000Selection" );
  226.         NXGetTempFilename(filename,9);
  227.         infile=fopen(filename,"w");
  228.         fprintf(infile,outbuffer);
  229.         fclose(infile);
  230.         NXZoneFree([self zone], outbuffer);
  231.         if ( (infile = fopen(filename, "r") ) == NULL ) {
  232.         *errorMsg = "Couldn't open /tmp file";
  233.         return nil;
  234.         }
  235.         binFlag = NO;
  236.         NX_ZONEMALLOC( [self zone], ntlist, ntuple, 2 );
  237.         if ( !(ntlist[0] = h_fileParse( infile, NULL, 0) ) ) {
  238.         NXZoneFree([self zone], ntlist);
  239.         *errorMsg = "Couldn't interpret data as n-tuple";
  240.         return nil;
  241.         }
  242.         ntlist[1] = NULL;
  243.         irc = fclose( infile );
  244.         unlink(filename);
  245.         hTuple = [[HTuple allocFromZone:[self zone]]
  246.                           initTuple:ntlist[0] file:"From Pasteboard"
  247.                   by:NO mode:NO index:0];
  248.         [hTuple setFakeFilename:YES];
  249.         [tupleList addObject:hTuple];
  250.         [tupleBrowser loadColumnZero];
  251.         [self setTuple:ntlist[0] ];
  252.         [self showPanel];
  253.     }
  254.     }
  255.     return self;
  256. }
  257. - addTuple:(ntuple) nt
  258. {
  259.     id            hTuple;
  260.     
  261.     hTuple = [[HTuple allocFromZone:[self zone]]
  262.                    initTuple:nt file:"none"
  263.                       by:NO mode:YES index:0];
  264.     [hTuple setFakeFilename:YES];
  265.     [tupleList addObject:hTuple];
  266.     [tupleBrowser loadColumnZero];
  267.     [ self setTuple:nt];
  268.     return hTuple;
  269. }
  270. - (ntuple) currentTuple
  271. {
  272.     id            browserMatrix;
  273.     id            hTuple;
  274.     ntuple        nt;
  275.     int            index;
  276.     
  277.     browserMatrix = [tupleBrowser matrixInColumn:0];
  278.     index = [browserMatrix selectedRow];
  279.     if ( index >= 0 ) {
  280.         hTuple = [tupleList objectAt:index];
  281.         nt = [hTuple ntuple];
  282.     } else {
  283.         nt = NULL;
  284.     }
  285.     return nt;
  286. }
  287.  
  288. - currentHTuple
  289. {
  290.     id        browserMatrix;
  291.     id        hTuple;
  292.     int        index;
  293.     
  294.     browserMatrix = [tupleBrowser matrixInColumn:0];
  295.     index = [browserMatrix selectedRow];
  296.     if ( index >= 0 ) {
  297.         hTuple = [tupleList objectAt:index];
  298.     } else {
  299.         hTuple = nil;
  300.     }
  301.     return hTuple;
  302. }
  303.  
  304. - bindDisplays
  305. {
  306.     id        windowList;
  307.     id        window, document, view;
  308.     int        wcount;
  309.     
  310.     windowList = [NXApp windowList];
  311.     wcount = [windowList count];
  312.     while ( wcount-- ) {
  313.         window = [windowList objectAt:wcount];
  314.     document = [window delegate];
  315.     if ( [document isKindOf:[DrawDocument class]] ) {
  316.         view = [document view];
  317.         [view bindDisplays];
  318.             [view reDrawPlot];
  319.     }
  320.     }        
  321.     return self;
  322. }
  323.  
  324. - addTuplesIfAbsent:newList for:aView
  325. {
  326.     id        newTuple, hTuple;
  327.     int        newCount, count;
  328.     int        i, j, irc;
  329.     BOOL    isNew;
  330.     
  331.     newCount = [newList count];
  332.     for ( i = 0; i < newCount; i++ ) {
  333.         newTuple = [newList objectAt:i];
  334.     isNew = YES;
  335.     count = [tupleList count];
  336.     for ( j = 0; j < count; j++ ) {
  337.         hTuple = [tupleList objectAt:j];
  338.         if ( [hTuple isSameAs:newTuple] ) {
  339.             isNew = NO;
  340.         [aView replace:newTuple with:hTuple];
  341.         [newTuple free];
  342.         break;
  343.         }
  344.     }
  345.     if ( isNew ) {
  346.         if ( [newTuple isRef ] ) {
  347.             irc = [self openTupleFile:[newTuple filename] by:YES];
  348.         if ( irc == HD_NOTEXIST ) {
  349.             [ self openAltTupleFile:[newTuple filename]];
  350.         }
  351.         j = [tupleList count];
  352.         while ( j-- ) {
  353.             hTuple = [tupleList objectAt:j];
  354.             if ( [hTuple isSameAs:newTuple] ) {
  355.                 [aView replace:newTuple with:hTuple];
  356.             [newTuple free];
  357.             break;
  358.             }
  359.         }
  360.         } else {
  361.         [tupleList addObject:newTuple];
  362.         [tupleBrowser loadColumnZero];
  363.         [ self setTuple:[newTuple ntuple]];
  364.         }
  365.     }
  366.     }
  367.     [self showPanel];
  368.     return self;
  369. }
  370. - (int) openTupleFile:(const char *)filename by:(BOOL) refFlag
  371. {
  372.     id            newTupleList;
  373.     struct stat        statbuf;
  374.     int            irc, rvalue;
  375.     
  376.     
  377.     if ( stat(filename, &statbuf) ) {
  378.         return HD_NOTEXIST;
  379.     }
  380.     rvalue = HD_OK;
  381.     if( ![self isNewTupleFile:filename] ) {
  382.         irc = NXRunAlertPanel( "Open", "Tuple file already open",
  383.                            "Replace", "Cancel", NULL);
  384.     if ( irc != NX_ALERTDEFAULT ) {
  385.         return HD_CANCEL;
  386.     }
  387.     [self closeTupleFile:filename];
  388.     rvalue = HD_REPLACE;
  389.     }               
  390.     if ( !(newTupleList = [self openTupleFromFile:filename by:refFlag]) ) {
  391.     irc = NXRunAlertPanel("Open", "Couldn't open file",
  392.             "OK", NULL, NULL);
  393.     return HD_CANCEL;
  394.     }
  395.     [newTupleList free];
  396.     return rvalue;
  397. }
  398. - openAltTupleFile:(const char *)filename
  399. {
  400.     id            newTupleList;
  401.     id            hTuple;
  402.     const char         *newfilename;
  403.     char        *suffix;
  404.     float        gray;
  405.     int            i, count;
  406.     int            rows, cols;
  407.     int                 irc;
  408.     BOOL        refFlag;
  409.  
  410.     [msgMatrix getNumRows:&rows numCols:&cols];
  411.     for (i = 0; i < rows; i++) {
  412.     [[msgMatrix cellAt:i :0] setTextGray:0.];
  413.     }
  414.     [[msgMatrix cellAt:1 :0] setStringValue:filename];
  415.     
  416.     suffix = rindex(filename, '.');
  417.     if (suffix && (strcmp(suffix, ".hippo") == 0)) {
  418.     irc = [self runModelForTypes];
  419.     } else {
  420.     [openPanel setAccessoryView:accessoryView];
  421.     if ( ![openPanel runModal] ) {
  422.         irc = HD_CANCEL;
  423.     } else {
  424.         irc = HD_OK;
  425.         }
  426.     }
  427.     gray = [msgMatrix backgroundGray];
  428.     for (i = 0; i < rows; i++) {
  429.     [[msgMatrix cellAt:i :0] setTextGray:gray];
  430.     }
  431.     if ( irc == HD_CANCEL ) {
  432.         return self;
  433.     }
  434.     
  435.     newfilename = [openPanel filename];
  436.     if ( ![self isNewTupleFile:newfilename] ) {
  437.         newTupleList = [self tupleListForFile:newfilename];
  438.     count = [newTupleList count];
  439.     for ( i = 0; i < count; i++ ) {
  440.         hTuple = [newTupleList objectAt:i];
  441.         [hTuple setAltFilename:filename];
  442.     }
  443.     return self;
  444.     }
  445.     refFlag = [refFlagMatrix selectedRow] ? NO : YES;
  446.     if ( !(newTupleList = [self openTupleFromFile:newfilename by:refFlag]) ) {
  447.     irc = NXRunAlertPanel("Open", "Couldn't open file",
  448.             "OK", NULL, NULL);
  449.     return self;
  450.     }
  451.     count = [newTupleList count];
  452.     for ( i = 0; i < count; i++ ) {
  453.         hTuple = [newTupleList objectAt:i];
  454.     [hTuple setAltFilename:filename];
  455.     }
  456.     return self;
  457. }
  458. - closeTupleFile:(const char *)filename
  459. {
  460.     id        windowList;
  461.     id        window, document, view;
  462.     id        hTuple;
  463.     int        count;
  464.     
  465.     windowList = [NXApp windowList];
  466.     count = [windowList count];
  467.     while ( count-- ) {
  468.         window = [windowList objectAt:count];
  469.     document = [window delegate];
  470.     if ( [document isKindOf:[DrawDocument class]] ) {
  471.         view = [document view];
  472.         [view closeTupleFile:filename];
  473.     }
  474.     }
  475.     tmpTupleList = [self tupleListForFile:filename];
  476.     count = [tmpTupleList count];
  477.     while ( count-- ) {
  478.         hTuple = [tmpTupleList objectAt:count];
  479.     [tupleList removeObject:hTuple];
  480.     }
  481.     [tupleBrowser reloadColumn:0];
  482.     [self browserSelect:self];
  483.     [tmpTupleList freeObjects];
  484.     return self;
  485. }
  486. - tupleListForFile:(const char *) filename
  487. {
  488.     id        hTuple;
  489.     int        i, count;
  490.     
  491.     if ( tmpTupleList ) {
  492.         [tmpTupleList empty];
  493.     } else {
  494.         tmpTupleList = [[List allocFromZone:[self zone]] initCount: 0];
  495.     }
  496.     count = [tupleList count];
  497.     for ( i = 0; i < count; i++ ) {
  498.         hTuple = [tupleList objectAt:i];
  499.     if ( strcmp( [hTuple filename], filename ) == 0 ) {
  500.             [tmpTupleList addObject:hTuple];
  501.     }
  502.     }
  503.     return tmpTupleList;
  504. }
  505. - showPanel
  506. {
  507.     theInspector = [hDraw newInspector];
  508.     [theInspector show:"Tuple List"];
  509.     [theInspector orderFrontPanel:self];
  510.     return self;
  511. }
  512. - select:sender
  513. {
  514.     selectedTuple = [self currentTuple];
  515.     return self;
  516. }
  517.  
  518. - replace:sender
  519. {
  520.     id             browserMatrix;
  521.     id             doc;
  522.     id            hTuple;
  523.     int            index;
  524.     
  525.     doc = [hDraw currentDocument];
  526.     if ( !doc ) return self;
  527.     graphicView = [doc view];
  528.     browserMatrix = [tupleBrowser matrixInColumn:0];
  529.     index = [browserMatrix selectedRow];
  530.     if ( index < 0 ) return self;
  531.     hTuple = [tupleList objectAt:index];
  532.     selectedTuple = [hTuple ntuple];
  533.     [graphicView graphicsPerform:@selector(replaceTupleWith:)
  534.         with: hTuple andDraw:YES ];
  535.     [[graphicView window] flushWindow];
  536.     return self;
  537. }
  538.  
  539. - close:sender
  540. {
  541.     id        windowList;
  542.     id        window, document, view;
  543.     id        usedTupleList;
  544.     id        hTuple;
  545.     id         browserMatrix;
  546.     int        wcount;
  547.     int        i, irc, index;
  548.     
  549.     browserMatrix = [tupleBrowser matrixInColumn:0];
  550.     index = [browserMatrix selectedRow];
  551.     if ( index < 0 ) return self;
  552.     hTuple = [tupleList objectAt:index];
  553.     windowList = [NXApp windowList];
  554.     wcount = [windowList count];
  555.     while ( wcount-- ) {
  556.         window = [windowList objectAt:wcount];
  557.     document = [window delegate];
  558.     if ( [document isKindOf:[DrawDocument class]] ) {
  559.         view = [document view];
  560.         usedTupleList = [view tupleList];
  561.         i = [usedTupleList indexOf:hTuple];
  562.         if ( i != NX_NOT_IN_LIST ) {
  563.             irc = NXRunAlertPanel( "Close", "Tuple in use",
  564.                                    "OK", NULL, NULL);
  565.         return self;
  566.         }
  567.     }
  568.     }        
  569.     [self closeTupleFile:[hTuple filename]];
  570.     return self;
  571. }
  572. - browserSelect:sender
  573. {
  574.     id            browserMatrix;
  575.     id            hTuple;
  576.     ntuple        nt;
  577.     char        filename[FILENAME_MAX];
  578.     float        mb;
  579.     int            i, index, rows, cols;
  580.  
  581.     browserMatrix = [tupleBrowser matrixInColumn:0];
  582.     index = [browserMatrix selectedRow];
  583.     if ( index < 0 ) {
  584.         for ( i = 0; i < 4; i ++ ) {
  585.         [fileForm setStringValue:"" at:i];
  586.     }
  587.     return self;
  588.     }
  589.     hTuple = [tupleList objectAt:index];
  590.     nt = [hTuple ntuple];
  591.     rows = h_getNtNdata(nt);
  592.     cols = h_getNtDim(nt);
  593.     mb = (4*rows*cols)/1000000.;
  594.     
  595.     strcpy( filename, NXHomeDirectory() );
  596.     index = strspn( [hTuple filename], filename );
  597.     if ( index != (strlen(filename) + 1) ) {
  598.         strcpy( filename, [hTuple filename]); /* not in home directory */
  599.     } else {
  600.         strcpy( filename, "~");        /* file in home directory */
  601.     strcat( filename, [hTuple filename]+(index-1) );
  602.     }
  603.     
  604.     [ fileForm setStringValue:filename at:0];
  605.     [ fileForm setIntValue:cols at:1];
  606.     [ fileForm setIntValue:rows at:2];
  607.     [ fileForm setFloatValue:mb at:3];
  608.     return self;
  609. }    
  610. - updateView
  611. {
  612.     id                  browserMatrix;
  613.  
  614.     browserMatrix = [tupleBrowser matrixInColumn:0];
  615.     if ( !selectedPlot ) {
  616.         [browserMatrix selectCellAt:-1 :-1];
  617.     return self;
  618.     }
  619.     [self setTuple:[selectedPlot ntuple]];
  620.     if (selectedTuple == NULL) {
  621.         [browserMatrix selectCellAt:-1 :-1];
  622.     return self;
  623.     }
  624.     return self;
  625. }
  626. - setTuple:(ntuple) atuple
  627. {
  628.     id                  browserMatrix;
  629.     id            hTuple;
  630.     unsigned int    i, count;
  631.     
  632.     if (selectedTuple == atuple)
  633.     return self;
  634.     selectedTuple = atuple;
  635.     if (selectedTuple == NULL)
  636.     return self;
  637.     browserMatrix = [tupleBrowser matrixInColumn:0];
  638.     count = [tupleList count];
  639.     for ( i = 0; i < count; i++ ) {
  640.         hTuple = [tupleList objectAt:i];
  641.         if ( selectedTuple == [hTuple ntuple] ) {
  642.         [ browserMatrix selectCellAt:i :0];
  643.         [ self browserSelect:self];
  644.         break;
  645.     }
  646.     }
  647.     return self;
  648. }
  649. /* Delegate Methods for NXBrowsers */
  650. - (int) browser: sender fillMatrix: matrix inColumn: (int) column
  651. {
  652.     id                  aCell;
  653.     id            hTuple;
  654.     const char        *title;
  655.     int                 i, count;
  656.  
  657.     count = [tupleList count];
  658.     for (i = 0; i < count; i++) {
  659.     [matrix insertRowAt:i];
  660.     aCell = [matrix cellAt:i :0];
  661.     hTuple = [tupleList objectAt:i];
  662.     title = [hTuple title];
  663.     if ( title && strcmp(title, "") ) {
  664.         [aCell setStringValue:title];
  665.     } else {
  666.         [aCell setStringValue:"<none>"];
  667.     }
  668.     [aCell setLeaf:YES];
  669.     [aCell setLoaded:YES];
  670.     }
  671.     [matrix allowEmptySel:NO];
  672.     return count;
  673. }
  674. - setMsgMatrix:anObject
  675. {
  676.     float    gray;
  677.     int        i, rows, cols;
  678.     
  679.     msgMatrix = anObject;
  680.     gray = [msgMatrix backgroundGray ];
  681.     [msgMatrix getNumRows:&rows numCols:&cols];
  682.     for ( i = 0; i < rows; i++ ) {
  683.        [[msgMatrix cellAt:i :0] setTextGray:gray];
  684.     }
  685.     return self;
  686. }
  687. /* Obsolete methods, maintained for backward compatibility */
  688. - newTuple:(ntuple) nt 
  689. {
  690.  
  691.    [self addTuple:nt];
  692.    return self;
  693. }
  694. @end
  695.